/// //消息签名，防篡改
use ring::{digest, hmac, rand};

fn generate_mac(key: &[u8], message: &[u8]) -> hmac::Tag {
    // 创建 HMAC SHA-256 上下文
    let hmac_key = hmac::Key::new(hmac::HMAC_SHA256, key);
    let mut context = hmac::Context::with_key(&hmac_key);

    // 添加消息进行哈希
    context.update(message);

    // 计算最终的 HMAC
    context.sign()
}

fn verify_mac(key: &[u8], message: &[u8], expected_mac: &hmac::Tag) -> bool {
    // 生成期望的 HMAC
    let generated_mac = generate_mac(key, message);

    // 使用 `verify` 方法验证生成的 HMAC 与期望的 HMAC 是否相同
    generated_mac.as_ref() == expected_mac.as_ref()
}

//消息签名，防篡改
//消息验证码（MAC）是一种用于验证消息完整性的密码学技术，通常使用哈希函数和密钥来生成。在 Rust 中，可以使用 ring 库来实现消息验证码。以下是一个简单的例子，演示如何使用 ring 库生成和验证 HMAC SHA-256（一种常见的 MAC）：
#[test]
fn test() {
    // 我们将使用一个简单的密钥和消息来演示 HMAC 的工作方式。

    // 密钥（在实际应用中应该是安全生成和存储的）
    let key = b"secret_key";

    //要传输的消息
    let message = b"message";

    // 生成 HMAC
    let mac = generate_mac(key, message);

    // 在实际应用中，`mac` 将与消息一起传输到接收方

    // 验证 HMAC
    assert!(verify_mac(key, b"message", &mac));
}

//签署一个值并验证它未被篡改
#[test]
fn test1() {
    let rng = rand::SystemRandom::new();
    let key = hmac::Key::generate(hmac::HMAC_SHA256, &rng).unwrap();

    let msg = "hello, world";

    let tag = hmac::sign(&key, msg.as_bytes());

    // [We give access to the message to an untrusted party, and they give it
    // back to us. We need to verify they didn't tamper with it.]

    hmac::verify(&key, msg.as_bytes(), tag.as_ref()).expect("验证失败");
}

//使用一次性 API：
#[test]
fn test2() {
    let msg = "hello, world";

    // The sender generates a secure key value and signs the message with it.
    // Note that in a real protocol, a key agreement protocol would be used to
    // derive `key_value`.
    let rng = rand::SystemRandom::new();
    let key_value: [u8; digest::SHA256_OUTPUT_LEN] = rand::generate(&rng).unwrap().expose();

    let s_key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref());
    let tag = hmac::sign(&s_key, msg.as_bytes());

    // The receiver (somehow!) knows the key value, and uses it to verify the
    // integrity of the message.
    let v_key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref());
    hmac::verify(&v_key, msg.as_bytes(), tag.as_ref()).expect("验证失败");
}

//使用多部分 API：
#[test]
fn test3() {
    let parts = ["hello", ", ", "world"];

    // The sender generates a secure key value and signs the message with it.
    // Note that in a real protocol, a key agreement protocol would be used to
    // derive `key_value`.
    let rng = rand::SystemRandom::new();
    let mut key_value: [u8; digest::SHA384_OUTPUT_LEN] = rand::generate(&rng).unwrap().expose();

    let s_key = hmac::Key::new(hmac::HMAC_SHA384, key_value.as_ref());
    let mut s_ctx = hmac::Context::with_key(&s_key);
    for part in &parts {
        s_ctx.update(part.as_bytes());
    }
    let tag = s_ctx.sign();

    // The receiver (somehow!) knows the key value, and uses it to verify the
    // integrity of the message.
    let v_key = hmac::Key::new(hmac::HMAC_SHA384, key_value.as_ref());
    let mut msg = Vec::<u8>::new();
    for part in &parts {
        msg.extend(part.as_bytes());
    }
    hmac::verify(&v_key, &msg.as_ref(), tag.as_ref()).expect("验证失败");
}
